/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package logica.jpaControllers;

import Entidades.Proveedor;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import Entidades.Localidad;
import Entidades.Pais;
import Entidades.Provincia;
import Entidades.Contrato;
import java.util.ArrayList;
import java.util.Collection;
import Entidades.Proveedorproducto;
import Entidades.Remito;
import logica.jpaControllers.exceptions.IllegalOrphanException;
import logica.jpaControllers.exceptions.NonexistentEntityException;

/**
 *
 * @author Anali
 */
public class ProveedorJpaController {

    public ProveedorJpaController() {
        emf = Persistence.createEntityManagerFactory("GestorPesajeJpaPU2");
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Proveedor proveedor) {
        if (proveedor.getContratoCollection() == null) {
            proveedor.setContratoCollection(new ArrayList<Contrato>());
        }
        if (proveedor.getProveedorproductoCollection() == null) {
            proveedor.setProveedorproductoCollection(new ArrayList<Proveedorproducto>());
        }
        if (proveedor.getRemitoCollection() == null) {
            proveedor.setRemitoCollection(new ArrayList<Remito>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Localidad localidad = proveedor.getLocalidad();
            if (localidad != null) {
                localidad = em.getReference(localidad.getClass(), localidad.getIdlocalidad());
                proveedor.setLocalidad(localidad);
            }
            Pais pais = proveedor.getPais();
            if (pais != null) {
                pais = em.getReference(pais.getClass(), pais.getIdpais());
                proveedor.setPais(pais);
            }
            Provincia provincia = proveedor.getProvincia();
            if (provincia != null) {
                provincia = em.getReference(provincia.getClass(), provincia.getIdprovincia());
                proveedor.setProvincia(provincia);
            }
            Collection<Contrato> attachedContratoCollection = new ArrayList<Contrato>();
            for (Contrato contratoCollectionContratoToAttach : proveedor.getContratoCollection()) {
                contratoCollectionContratoToAttach = em.getReference(contratoCollectionContratoToAttach.getClass(), contratoCollectionContratoToAttach.getNumeroContrato());
                attachedContratoCollection.add(contratoCollectionContratoToAttach);
            }
            proveedor.setContratoCollection(attachedContratoCollection);
            Collection<Proveedorproducto> attachedProveedorproductoCollection = new ArrayList<Proveedorproducto>();
            for (Proveedorproducto proveedorproductoCollectionProveedorproductoToAttach : proveedor.getProveedorproductoCollection()) {
                proveedorproductoCollectionProveedorproductoToAttach = em.getReference(proveedorproductoCollectionProveedorproductoToAttach.getClass(), proveedorproductoCollectionProveedorproductoToAttach.getIdproveedorproducto());
                attachedProveedorproductoCollection.add(proveedorproductoCollectionProveedorproductoToAttach);
            }
            proveedor.setProveedorproductoCollection(attachedProveedorproductoCollection);
            Collection<Remito> attachedRemitoCollection = new ArrayList<Remito>();
            for (Remito remitoCollectionRemitoToAttach : proveedor.getRemitoCollection()) {
                remitoCollectionRemitoToAttach = em.getReference(remitoCollectionRemitoToAttach.getClass(), remitoCollectionRemitoToAttach.getIdRemito());
                attachedRemitoCollection.add(remitoCollectionRemitoToAttach);
            }
            proveedor.setRemitoCollection(attachedRemitoCollection);
            em.persist(proveedor);
            if (localidad != null) {
                localidad.getProveedorCollection().add(proveedor);
                localidad = em.merge(localidad);
            }
            if (pais != null) {
                pais.getProveedorCollection().add(proveedor);
                pais = em.merge(pais);
            }
            if (provincia != null) {
                provincia.getProveedorCollection().add(proveedor);
                provincia = em.merge(provincia);
            }
            for (Contrato contratoCollectionContrato : proveedor.getContratoCollection()) {
                Proveedor oldProveedorOfContratoCollectionContrato = contratoCollectionContrato.getProveedor();
                contratoCollectionContrato.setProveedor(proveedor);
                contratoCollectionContrato = em.merge(contratoCollectionContrato);
                if (oldProveedorOfContratoCollectionContrato != null) {
                    oldProveedorOfContratoCollectionContrato.getContratoCollection().remove(contratoCollectionContrato);
                    oldProveedorOfContratoCollectionContrato = em.merge(oldProveedorOfContratoCollectionContrato);
                }
            }
            for (Proveedorproducto proveedorproductoCollectionProveedorproducto : proveedor.getProveedorproductoCollection()) {
                Proveedor oldProveedorOfProveedorproductoCollectionProveedorproducto = proveedorproductoCollectionProveedorproducto.getProveedor();
                proveedorproductoCollectionProveedorproducto.setProveedor(proveedor);
                proveedorproductoCollectionProveedorproducto = em.merge(proveedorproductoCollectionProveedorproducto);
                if (oldProveedorOfProveedorproductoCollectionProveedorproducto != null) {
                    oldProveedorOfProveedorproductoCollectionProveedorproducto.getProveedorproductoCollection().remove(proveedorproductoCollectionProveedorproducto);
                    oldProveedorOfProveedorproductoCollectionProveedorproducto = em.merge(oldProveedorOfProveedorproductoCollectionProveedorproducto);
                }
            }
            for (Remito remitoCollectionRemito : proveedor.getRemitoCollection()) {
                Proveedor oldProveedorOfRemitoCollectionRemito = remitoCollectionRemito.getProveedor();
                remitoCollectionRemito.setProveedor(proveedor);
                remitoCollectionRemito = em.merge(remitoCollectionRemito);
                if (oldProveedorOfRemitoCollectionRemito != null) {
                    oldProveedorOfRemitoCollectionRemito.getRemitoCollection().remove(remitoCollectionRemito);
                    oldProveedorOfRemitoCollectionRemito = em.merge(oldProveedorOfRemitoCollectionRemito);
                }
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Proveedor proveedor) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Proveedor persistentProveedor = em.find(Proveedor.class, proveedor.getIdProveedor());
            Localidad localidadOld = persistentProveedor.getLocalidad();
            Localidad localidadNew = proveedor.getLocalidad();
            Pais paisOld = persistentProveedor.getPais();
            Pais paisNew = proveedor.getPais();
            Provincia provinciaOld = persistentProveedor.getProvincia();
            Provincia provinciaNew = proveedor.getProvincia();
            Collection<Contrato> contratoCollectionOld = persistentProveedor.getContratoCollection();
            Collection<Contrato> contratoCollectionNew = proveedor.getContratoCollection();
            Collection<Proveedorproducto> proveedorproductoCollectionOld = persistentProveedor.getProveedorproductoCollection();
            Collection<Proveedorproducto> proveedorproductoCollectionNew = proveedor.getProveedorproductoCollection();
            Collection<Remito> remitoCollectionOld = persistentProveedor.getRemitoCollection();
            Collection<Remito> remitoCollectionNew = proveedor.getRemitoCollection();
            List<String> illegalOrphanMessages = null;
            for (Contrato contratoCollectionOldContrato : contratoCollectionOld) {
                if (!contratoCollectionNew.contains(contratoCollectionOldContrato)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Contrato " + contratoCollectionOldContrato + " since its proveedor field is not nullable.");
                }
            }
            for (Proveedorproducto proveedorproductoCollectionOldProveedorproducto : proveedorproductoCollectionOld) {
                if (!proveedorproductoCollectionNew.contains(proveedorproductoCollectionOldProveedorproducto)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Proveedorproducto " + proveedorproductoCollectionOldProveedorproducto + " since its proveedor field is not nullable.");
                }
            }
            for (Remito remitoCollectionOldRemito : remitoCollectionOld) {
                if (!remitoCollectionNew.contains(remitoCollectionOldRemito)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Remito " + remitoCollectionOldRemito + " since its proveedor field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (localidadNew != null) {
                localidadNew = em.getReference(localidadNew.getClass(), localidadNew.getIdlocalidad());
                proveedor.setLocalidad(localidadNew);
            }
            if (paisNew != null) {
                paisNew = em.getReference(paisNew.getClass(), paisNew.getIdpais());
                proveedor.setPais(paisNew);
            }
            if (provinciaNew != null) {
                provinciaNew = em.getReference(provinciaNew.getClass(), provinciaNew.getIdprovincia());
                proveedor.setProvincia(provinciaNew);
            }
            Collection<Contrato> attachedContratoCollectionNew = new ArrayList<Contrato>();
            for (Contrato contratoCollectionNewContratoToAttach : contratoCollectionNew) {
                contratoCollectionNewContratoToAttach = em.getReference(contratoCollectionNewContratoToAttach.getClass(), contratoCollectionNewContratoToAttach.getNumeroContrato());
                attachedContratoCollectionNew.add(contratoCollectionNewContratoToAttach);
            }
            contratoCollectionNew = attachedContratoCollectionNew;
            proveedor.setContratoCollection(contratoCollectionNew);
            Collection<Proveedorproducto> attachedProveedorproductoCollectionNew = new ArrayList<Proveedorproducto>();
            for (Proveedorproducto proveedorproductoCollectionNewProveedorproductoToAttach : proveedorproductoCollectionNew) {
                proveedorproductoCollectionNewProveedorproductoToAttach = em.getReference(proveedorproductoCollectionNewProveedorproductoToAttach.getClass(), proveedorproductoCollectionNewProveedorproductoToAttach.getIdproveedorproducto());
                attachedProveedorproductoCollectionNew.add(proveedorproductoCollectionNewProveedorproductoToAttach);
            }
            proveedorproductoCollectionNew = attachedProveedorproductoCollectionNew;
            proveedor.setProveedorproductoCollection(proveedorproductoCollectionNew);
            Collection<Remito> attachedRemitoCollectionNew = new ArrayList<Remito>();
            for (Remito remitoCollectionNewRemitoToAttach : remitoCollectionNew) {
                remitoCollectionNewRemitoToAttach = em.getReference(remitoCollectionNewRemitoToAttach.getClass(), remitoCollectionNewRemitoToAttach.getIdRemito());
                attachedRemitoCollectionNew.add(remitoCollectionNewRemitoToAttach);
            }
            remitoCollectionNew = attachedRemitoCollectionNew;
            proveedor.setRemitoCollection(remitoCollectionNew);
            proveedor = em.merge(proveedor);
            if (localidadOld != null && !localidadOld.equals(localidadNew)) {
                localidadOld.getProveedorCollection().remove(proveedor);
                localidadOld = em.merge(localidadOld);
            }
            if (localidadNew != null && !localidadNew.equals(localidadOld)) {
                localidadNew.getProveedorCollection().add(proveedor);
                localidadNew = em.merge(localidadNew);
            }
            if (paisOld != null && !paisOld.equals(paisNew)) {
                paisOld.getProveedorCollection().remove(proveedor);
                paisOld = em.merge(paisOld);
            }
            if (paisNew != null && !paisNew.equals(paisOld)) {
                paisNew.getProveedorCollection().add(proveedor);
                paisNew = em.merge(paisNew);
            }
            if (provinciaOld != null && !provinciaOld.equals(provinciaNew)) {
                provinciaOld.getProveedorCollection().remove(proveedor);
                provinciaOld = em.merge(provinciaOld);
            }
            if (provinciaNew != null && !provinciaNew.equals(provinciaOld)) {
                provinciaNew.getProveedorCollection().add(proveedor);
                provinciaNew = em.merge(provinciaNew);
            }
            for (Contrato contratoCollectionNewContrato : contratoCollectionNew) {
                if (!contratoCollectionOld.contains(contratoCollectionNewContrato)) {
                    Proveedor oldProveedorOfContratoCollectionNewContrato = contratoCollectionNewContrato.getProveedor();
                    contratoCollectionNewContrato.setProveedor(proveedor);
                    contratoCollectionNewContrato = em.merge(contratoCollectionNewContrato);
                    if (oldProveedorOfContratoCollectionNewContrato != null && !oldProveedorOfContratoCollectionNewContrato.equals(proveedor)) {
                        oldProveedorOfContratoCollectionNewContrato.getContratoCollection().remove(contratoCollectionNewContrato);
                        oldProveedorOfContratoCollectionNewContrato = em.merge(oldProveedorOfContratoCollectionNewContrato);
                    }
                }
            }
            for (Proveedorproducto proveedorproductoCollectionNewProveedorproducto : proveedorproductoCollectionNew) {
                if (!proveedorproductoCollectionOld.contains(proveedorproductoCollectionNewProveedorproducto)) {
                    Proveedor oldProveedorOfProveedorproductoCollectionNewProveedorproducto = proveedorproductoCollectionNewProveedorproducto.getProveedor();
                    proveedorproductoCollectionNewProveedorproducto.setProveedor(proveedor);
                    proveedorproductoCollectionNewProveedorproducto = em.merge(proveedorproductoCollectionNewProveedorproducto);
                    if (oldProveedorOfProveedorproductoCollectionNewProveedorproducto != null && !oldProveedorOfProveedorproductoCollectionNewProveedorproducto.equals(proveedor)) {
                        oldProveedorOfProveedorproductoCollectionNewProveedorproducto.getProveedorproductoCollection().remove(proveedorproductoCollectionNewProveedorproducto);
                        oldProveedorOfProveedorproductoCollectionNewProveedorproducto = em.merge(oldProveedorOfProveedorproductoCollectionNewProveedorproducto);
                    }
                }
            }
            for (Remito remitoCollectionNewRemito : remitoCollectionNew) {
                if (!remitoCollectionOld.contains(remitoCollectionNewRemito)) {
                    Proveedor oldProveedorOfRemitoCollectionNewRemito = remitoCollectionNewRemito.getProveedor();
                    remitoCollectionNewRemito.setProveedor(proveedor);
                    remitoCollectionNewRemito = em.merge(remitoCollectionNewRemito);
                    if (oldProveedorOfRemitoCollectionNewRemito != null && !oldProveedorOfRemitoCollectionNewRemito.equals(proveedor)) {
                        oldProveedorOfRemitoCollectionNewRemito.getRemitoCollection().remove(remitoCollectionNewRemito);
                        oldProveedorOfRemitoCollectionNewRemito = em.merge(oldProveedorOfRemitoCollectionNewRemito);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = proveedor.getIdProveedor();
                if (findProveedor(id) == null) {
                    throw new NonexistentEntityException("The proveedor with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Proveedor proveedor;
            try {
                proveedor = em.getReference(Proveedor.class, id);
                proveedor.getIdProveedor();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The proveedor with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Collection<Contrato> contratoCollectionOrphanCheck = proveedor.getContratoCollection();
            for (Contrato contratoCollectionOrphanCheckContrato : contratoCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Proveedor (" + proveedor + ") cannot be destroyed since the Contrato " + contratoCollectionOrphanCheckContrato + " in its contratoCollection field has a non-nullable proveedor field.");
            }
            Collection<Proveedorproducto> proveedorproductoCollectionOrphanCheck = proveedor.getProveedorproductoCollection();
            for (Proveedorproducto proveedorproductoCollectionOrphanCheckProveedorproducto : proveedorproductoCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Proveedor (" + proveedor + ") cannot be destroyed since the Proveedorproducto " + proveedorproductoCollectionOrphanCheckProveedorproducto + " in its proveedorproductoCollection field has a non-nullable proveedor field.");
            }
            Collection<Remito> remitoCollectionOrphanCheck = proveedor.getRemitoCollection();
            for (Remito remitoCollectionOrphanCheckRemito : remitoCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Proveedor (" + proveedor + ") cannot be destroyed since the Remito " + remitoCollectionOrphanCheckRemito + " in its remitoCollection field has a non-nullable proveedor field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Localidad localidad = proveedor.getLocalidad();
            if (localidad != null) {
                localidad.getProveedorCollection().remove(proveedor);
                localidad = em.merge(localidad);
            }
            Pais pais = proveedor.getPais();
            if (pais != null) {
                pais.getProveedorCollection().remove(proveedor);
                pais = em.merge(pais);
            }
            Provincia provincia = proveedor.getProvincia();
            if (provincia != null) {
                provincia.getProveedorCollection().remove(proveedor);
                provincia = em.merge(provincia);
            }
            em.remove(proveedor);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Proveedor> findProveedorEntities() {
        return findProveedorEntities(true, -1, -1);
    }

    public List<Proveedor> findProveedorEntities(int maxResults, int firstResult) {
        return findProveedorEntities(false, maxResults, firstResult);
    }

    private List<Proveedor> findProveedorEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select object(o) from Proveedor as o");
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Proveedor findProveedor(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Proveedor.class, id);
        } finally {
            em.close();
        }
    }

    public int getProveedorCount() {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select count(o) from Proveedor as o");
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
 public Proveedor findProveedor_x_apellido(String ape) {
          EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select u from Proveedor u where u.apellidoProveedor = " + "'" + ape +"'");
            return (Proveedor) q.getSingleResult();
        } finally {
            em.close();
        }
    }

    public Proveedor findProveedor_x_razon(String razon) {
       EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select u from Proveedor u where u.razonSocialProveedor = " + "'" + razon +"'");
            return (Proveedor) q.getSingleResult();
        } finally {
            em.close();
        }
    }


 public List<Proveedor> findProveedorActivos() {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createNativeQuery("select * from proveedor as p where p.fechabaja=null", Proveedor.class);
             return q.getResultList();
        } finally {
            em.close();
        }

 }



    public Proveedor findProveedor_x_cuit(String cuit) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select u from Proveedor u where u.cuitProveedor = " + "'" + cuit +"'");
            return (Proveedor) q.getSingleResult();
        } finally {
            em.close();
        }
    }

    public List<Proveedor> findProveedorBaja() {

         EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select u from Proveedor u where u.fechabaja  <>'' ");
            return  q.getResultList();
        } finally {
            em.close();


    }
    }
}
